/**
 * @fileOverview The "tab" plugin. This plugin provides basic Tab/Shift-Tab key handling with the following behaviors:
 * Move to next/previous table cell, if within a table;
 * Move to next editor instance in page, otherwise;
 */
(function() {
   var meta = {
      editorFocus: false,
      modes: { wysiwyg:1,source:1 }
   };

   var blurCommand = {
      exec: function( editor ) {
         editor.container.focusNext( true, editor.tabIndex );
      }
   };

   var blurBackCommand = {
      exec: function( editor ) {
         editor.container.focusPrevious( true, editor.tabIndex );
      }
   };

   function selectNextCellCommand( backward ) {
      return {
         editorFocus: false,
         canUndo: false,
         modes: { wysiwyg:1 },
         exec: function( editor ) {
            if ( editor.editable().hasFocus ) {
               var sel = editor.getSelection(),
                  path = new VED.dom.elementPath( sel.getCommonAncestor(), sel.root ),
                  cell;

               if ( ( cell = path.contains( { td:1,th:1 }, 1 ) ) ) {
                  var resultRange = editor.createRange(),
                     next = VED.tools.tryThese( function() {
                        var row = cell.getParent(),
                           next = row.$.cells[ cell.$.cellIndex + ( backward ? -1 : 1 ) ];

                        // Invalid any empty value.
                        next.parentNode.parentNode;
                        return next;
                     }, function() {
                        var row = cell.getParent(),
                           table = row.getAscendant( 'table' ),
                           nextRow = table.$.rows[ row.$.rowIndex + ( backward ? -1 : 1 ) ];

                        return nextRow.cells[ backward ? nextRow.cells.length - 1 : 0 ];
                     });

                  // Clone one more row at the end of table and select the first newly established cell.
                  if ( !( next || backward ) ) {
                     var table = cell.getAscendant( 'table' ).$,
                        cells = cell.getParent().$.cells;

                     var newRow = new VED.dom.element( table.insertRow( -1 ), editor.document );

                     for ( var i = 0, count = cells.length; i < count; i++ ) {
                        var newCell = newRow.append( new VED.dom.element( cells[ i ], editor.document ).clone( false, false ) );
                        !VED.env.ie && newCell.appendBogus();
                     }

                     resultRange.moveToElementEditStart( newRow );
                  } else if ( next ) {
                     next = new VED.dom.element( next );
                     resultRange.moveToElementEditStart( next );
                     // Avoid selecting empty block makes the cursor blind.
                     if ( !( resultRange.checkStartOfBlock() && resultRange.checkEndOfBlock() ) )
                        resultRange.selectNodeContents( next );
                  } else
                     return true;

                  resultRange.select( true );
                  return true;
               }
            }

            return false;
         }
      };
   }

   VED.plugins.add( 'tab', {
      init: function( editor ) {
         var tabTools = editor.config.enableTabKeyTools !== false,
            tabSpaces = editor.config.tabSpaces || 0,
            tabText = '';

         while ( tabSpaces-- )
            tabText += '\xa0';

         if ( tabText ) {
            editor.on( 'key', function( ev ) {
               if ( ev.data.keyCode == 9 ) // TAB
               {
                  editor.insertHtml( tabText );
                  ev.cancel();
               }
            });
         }

         if ( tabTools ) {
            editor.on( 'key', function( ev ) {
               if ( ev.data.keyCode == 9 && editor.execCommand( 'selectNextCell' ) || // TAB
               ev.data.keyCode == ( VED.SHIFT + 9 ) && editor.execCommand( 'selectPreviousCell' ) ) // SHIFT+TAB
               ev.cancel();
            });
         }

         editor.addCommand( 'blur', VED.tools.extend( blurCommand, meta ) );
         editor.addCommand( 'blurBack', VED.tools.extend( blurBackCommand, meta ) );
         editor.addCommand( 'selectNextCell', selectNextCellCommand() );
         editor.addCommand( 'selectPreviousCell', selectNextCellCommand( true ) );
      }
   });
})();

VED.dom.element.implement({
   focusNext: function( ignoreChildren, indexToUse ) {
      var $ = this.$,
         curTabIndex = ( indexToUse === undefined ? this.getTabIndex() : indexToUse ),
         passedCurrent, enteredCurrent, elected, electedTabIndex, element, elementTabIndex;

      if ( curTabIndex <= 0 ) {
         // If this element has tabindex <= 0 then we must simply look for any
         // element following it containing tabindex=0.

         element = this.getNextSourceNode( ignoreChildren, VED.NODE_ELEMENT );

         while ( element ) {
            if ( element.isVisible() && element.getTabIndex() === 0 ) {
               elected = element;
               break;
            }

            element = element.getNextSourceNode( false, VED.NODE_ELEMENT );
         }
      } else {
         // If this element has tabindex > 0 then we must look for:
         //      1. An element following this element with the same tabindex.
         //      2. The first element in source other with the lowest tabindex
         //         that is higher than this element tabindex.
         //      3. The first element with tabindex=0.

         element = this.getDocument().getBody().getFirst();

         while ( ( element = element.getNextSourceNode( false, VED.NODE_ELEMENT ) ) ) {
            if ( !passedCurrent ) {
               if ( !enteredCurrent && element.equals( this ) ) {
                  enteredCurrent = true;

                  // Ignore this element, if required.
                  if ( ignoreChildren ) {
                     if ( !( element = element.getNextSourceNode( true, VED.NODE_ELEMENT ) ) )
                        break;
                     passedCurrent = 1;
                  }
               } else if ( enteredCurrent && !this.contains( element ) )
                  passedCurrent = 1;
            }

            if ( !element.isVisible() || ( elementTabIndex = element.getTabIndex() ) < 0 )
               continue;

            if ( passedCurrent && elementTabIndex == curTabIndex ) {
               elected = element;
               break;
            }

            if ( elementTabIndex > curTabIndex && ( !elected || !electedTabIndex || elementTabIndex < electedTabIndex ) ) {
               elected = element;
               electedTabIndex = elementTabIndex;
            } else if ( !elected && elementTabIndex === 0 ) {
               elected = element;
               electedTabIndex = elementTabIndex;
            }
         }
      }

      if ( elected )
         elected.focus();
   },

   focusPrevious: function( ignoreChildren, indexToUse ) {
      var $ = this.$,
         curTabIndex = ( indexToUse === undefined ? this.getTabIndex() : indexToUse ),
         passedCurrent, enteredCurrent, elected,
         electedTabIndex = 0,
         elementTabIndex;

      var element = this.getDocument().getBody().getLast();

      while ( ( element = element.getPreviousSourceNode( false, VED.NODE_ELEMENT ) ) ) {
         if ( !passedCurrent ) {
            if ( !enteredCurrent && element.equals( this ) ) {
               enteredCurrent = true;

               // Ignore this element, if required.
               if ( ignoreChildren ) {
                  if ( !( element = element.getPreviousSourceNode( true, VED.NODE_ELEMENT ) ) )
                     break;
                  passedCurrent = 1;
               }
            } else if ( enteredCurrent && !this.contains( element ) )
               passedCurrent = 1;
         }

         if ( !element.isVisible() || ( elementTabIndex = element.getTabIndex() ) < 0 )
            continue;

         if ( curTabIndex <= 0 ) {
            // If this element has tabindex <= 0 then we must look for:
            //      1. An element before this one containing tabindex=0.
            //      2. The last element with the highest tabindex.

            if ( passedCurrent && elementTabIndex === 0 ) {
               elected = element;
               break;
            }

            if ( elementTabIndex > electedTabIndex ) {
               elected = element;
               electedTabIndex = elementTabIndex;
            }
         } else {
            // If this element has tabindex > 0 we must look for:
            //      1. An element preceeding this one, with the same tabindex.
            //      2. The last element in source other with the highest tabindex
            //         that is lower than this element tabindex.

            if ( passedCurrent && elementTabIndex == curTabIndex ) {
               elected = element;
               break;
            }

            if ( elementTabIndex < curTabIndex && ( !elected || elementTabIndex > electedTabIndex ) ) {
               elected = element;
               electedTabIndex = elementTabIndex;
            }
         }
      }

      if ( elected )
         elected.focus();
   }
});

// If the TAB key is not supposed to be enabled for navigation, the following
// settings could be used alternatively:
// config.keystrokes.push(
//   [ VED.ALT + 38 /*Arrow Up*/, 'selectPreviousCell' ],
//   [ VED.ALT + 40 /*Arrow Down*/, 'selectNextCell' ]
// );





